home *** CD-ROM | disk | FTP | other *** search
/ Champak 141 / (Vol 141) Oct 17 2011.iso / Games / Clueless.swf / scripts / Cutscene / CutsceneManager.as < prev    next >
Encoding:
Text File  |  2011-10-17  |  10.5 KB  |  350 lines
  1. package Cutscene
  2. {
  3.    import Common.ResourceManager;
  4.    import Common.SoundManager;
  5.    import flash.display.DisplayObject;
  6.    import flash.display.MovieClip;
  7.    import flash.display.SimpleButton;
  8.    import flash.events.Event;
  9.    import flash.events.MouseEvent;
  10.    import flash.text.TextField;
  11.    import flash.utils.clearTimeout;
  12.    import flash.utils.setTimeout;
  13.    
  14.    public class CutsceneManager
  15.    {
  16.       
  17.       public static const C_DIALOGUE_SPEED:* = 1;
  18.       
  19.       private static var instance:CutsceneManager;
  20.        
  21.       
  22.       private var curTxtDelta:uint = 0;
  23.       
  24.       private var scene:MovieClip = null;
  25.       
  26.       private var curCutsceneName:String = "";
  27.       
  28.       private var txtName:TextField = null;
  29.       
  30.       private var curTxtDisplayCount:uint = 0;
  31.       
  32.       private var cutsceneScripts:Array;
  33.       
  34.       private var resources:ResourceManager;
  35.       
  36.       private var currentTimeout:uint = 0;
  37.       
  38.       private var cutsceneDecisions:Array;
  39.       
  40.       private var cutsceneResolves:Array;
  41.       
  42.       private var cutsceneFileName:String = "";
  43.       
  44.       private var dialogueBox:MovieClip = null;
  45.       
  46.       private var cutsceneResolvePlugin:ICutsceneResolvePlugin;
  47.       
  48.       private var sceneParent:MovieClip = null;
  49.       
  50.       private var txtDialogue:TextField = null;
  51.       
  52.       private var loadToSceneAfterLoading:Boolean = true;
  53.       
  54.       private var curCutscene:CutsceneState = null;
  55.       
  56.       public function CutsceneManager()
  57.       {
  58.          cutsceneFileName = "";
  59.          resources = new ResourceManager();
  60.          cutsceneScripts = [];
  61.          cutsceneResolves = [];
  62.          cutsceneDecisions = [];
  63.          curCutscene = null;
  64.          curCutsceneName = "";
  65.          txtName = null;
  66.          txtDialogue = null;
  67.          dialogueBox = null;
  68.          scene = null;
  69.          sceneParent = null;
  70.          curTxtDisplayCount = 0;
  71.          curTxtDelta = 0;
  72.          currentTimeout = 0;
  73.          loadToSceneAfterLoading = true;
  74.          super();
  75.       }
  76.       
  77.       public static function getInstance() : CutsceneManager
  78.       {
  79.          if(instance == null)
  80.          {
  81.             instance = new CutsceneManager();
  82.          }
  83.          return instance;
  84.       }
  85.       
  86.       public function get CurrentCutscene() : CutsceneState
  87.       {
  88.          return curCutscene;
  89.       }
  90.       
  91.       public function loadCutsceneFromName(param1:String) : *
  92.       {
  93.          curCutsceneName = param1;
  94.          loadBackground();
  95.          loadCutscene();
  96.       }
  97.       
  98.       public function setSceneParent(param1:MovieClip) : *
  99.       {
  100.          this.sceneParent = param1;
  101.       }
  102.       
  103.       public function set LoadToSceneAfterLoading(param1:Boolean) : *
  104.       {
  105.          this.loadToSceneAfterLoading = param1;
  106.       }
  107.       
  108.       public function loadCutscene() : *
  109.       {
  110.          if(curCutscene != cutsceneScripts[curCutsceneName])
  111.          {
  112.             curCutscene = cutsceneScripts[curCutsceneName];
  113.             if(curCutscene.loadCutscene(scene,resources) == 2)
  114.             {
  115.                nextPage();
  116.             }
  117.             dialogueBox.visible = !curCutscene.IsDialogueBoxInvisible;
  118.             curTxtDisplayCount = 0;
  119.          }
  120.       }
  121.       
  122.       public function nextPage() : *
  123.       {
  124.          var _loc1_:CutsceneResolve = null;
  125.          var _loc2_:Boolean = false;
  126.          _loc1_ = null;
  127.          _loc2_ = true;
  128.          clearTimeout(currentTimeout);
  129.          if(curCutscene == null)
  130.          {
  131.             return;
  132.          }
  133.          while(_loc2_)
  134.          {
  135.             switch(curCutscene.nextPage())
  136.             {
  137.                case -1:
  138.                   _loc2_ = false;
  139.                   return;
  140.                case 0:
  141.                   if(cutsceneResolvePlugin != null)
  142.                   {
  143.                      _loc1_ = cutsceneResolves[curCutscene.DefaultResolve];
  144.                      cutsceneResolvePlugin.checkResolve(_loc1_.ResolveType,_loc1_.ResolveName,this.sceneParent);
  145.                   }
  146.                   _loc2_ = false;
  147.                   break;
  148.                case 1:
  149.                   _loc2_ = false;
  150.                   break;
  151.                case 2:
  152.                   break;
  153.             }
  154.          }
  155.          curTxtDisplayCount = 0;
  156.       }
  157.       
  158.       public function unloadCutscene(param1:Boolean) : *
  159.       {
  160.          if(curCutscene != null)
  161.          {
  162.             curCutscene.unloadCutscene(param1);
  163.             curCutscene = null;
  164.          }
  165.       }
  166.       
  167.       public function setCutsceneDisplayElements(param1:TextField, param2:TextField, param3:MovieClip, param4:TextField, param5:SimpleButton, param6:MovieClip, param7:MovieClip) : *
  168.       {
  169.          this.txtName = param1;
  170.          this.txtDialogue = param2;
  171.          this.dialogueBox = param6;
  172.          this.scene = param7;
  173.          CutsceneDialogue.txtDialogue = param2;
  174.          CutsceneDialogue.txtOwner = param1;
  175.          CutsceneDialogue.txtOwnerbg_mc = param3;
  176.          CutsceneDialogue.dialogueBox = param6;
  177.          CutsceneDialogue.txtSkip = param4;
  178.          CutsceneDialogue.txtSkipButton_mc = param5;
  179.       }
  180.       
  181.       public function loadBackground() : *
  182.       {
  183.          cutsceneScripts[curCutsceneName].loadBG(scene);
  184.       }
  185.       
  186.       public function getResolve(param1:String) : *
  187.       {
  188.          return cutsceneResolves[param1];
  189.       }
  190.       
  191.       public function queueLoadCutscene(param1:XML) : *
  192.       {
  193.          var resolveNode:XML = null;
  194.          var stateNode:XML = null;
  195.          var resolve:CutsceneResolve = null;
  196.          var cutscene:CutsceneState = null;
  197.          var xmlParent:XML = param1;
  198.          try
  199.          {
  200.             cutsceneFileName = xmlParent.@name.toString();
  201.             curCutsceneName = xmlParent.@initCutscene.toString();
  202.             resources.Root = xmlParent.Res.@root;
  203.             resources.loadResource();
  204.             for each(resolveNode in xmlParent.Resolves.elements())
  205.             {
  206.                resolve = CutsceneResolve.fromXML(resolveNode,scene);
  207.                cutsceneResolves[resolve.Name] = resolve;
  208.             }
  209.             for each(stateNode in xmlParent.States.elements())
  210.             {
  211.                cutscene = CutsceneState.fromXML(stateNode,scene);
  212.                cutsceneScripts[cutscene.Name] = cutscene;
  213.             }
  214.             if(loadToSceneAfterLoading)
  215.             {
  216.                resources.CallbackFunction = loadCutscene;
  217.             }
  218.          }
  219.          catch(e:TypeError)
  220.          {
  221.             trace("Could not parse text into XML");
  222.             trace(e.message);
  223.          }
  224.       }
  225.       
  226.       public function addPersonOverride(param1:String, param2:String, param3:DisplayObject) : *
  227.       {
  228.          curCutscene.addPersonOverride(param1,param2,param3);
  229.       }
  230.       
  231.       public function onPressSkip(param1:MouseEvent) : *
  232.       {
  233.          if(curCutscene == null || curCutscene.CurrentDialogue == null)
  234.          {
  235.             return;
  236.          }
  237.          if(curTxtDisplayCount < curCutscene.CurrentDialogue.LengthOfText)
  238.          {
  239.             curTxtDisplayCount = curCutscene.CurrentDialogue.LengthOfText;
  240.             curCutscene.CurrentDialogue.updateTextElement(curTxtDisplayCount);
  241.             if(txtDialogue.text == "...")
  242.             {
  243.                currentTimeout = setTimeout(nextPage,10000);
  244.             }
  245.             else if(curTxtDisplayCount < 20)
  246.             {
  247.                currentTimeout = setTimeout(nextPage,curTxtDisplayCount * 300);
  248.             }
  249.             else if(curTxtDisplayCount < 100)
  250.             {
  251.                currentTimeout = setTimeout(nextPage,curTxtDisplayCount * 100);
  252.             }
  253.             else
  254.             {
  255.                currentTimeout = setTimeout(nextPage,10000);
  256.             }
  257.          }
  258.          else
  259.          {
  260.             nextPage();
  261.          }
  262.       }
  263.       
  264.       public function update() : *
  265.       {
  266.          if(curCutscene == null)
  267.          {
  268.             return;
  269.          }
  270.          if(curTxtDelta == C_DIALOGUE_SPEED)
  271.          {
  272.             ++curTxtDisplayCount;
  273.             curTxtDelta = 0;
  274.             if(curCutscene != null && curCutscene.CurrentDialogue != null)
  275.             {
  276.                curCutscene.CurrentDialogue.updateTextElement(curTxtDisplayCount);
  277.                curCutscene.CurrentDialogue.talk(curCutscene,curTxtDisplayCount);
  278.             }
  279.          }
  280.          if(curTxtDisplayCount == curCutscene.CurrentDialogue.LengthOfText && curTxtDelta == 0)
  281.          {
  282.             if(txtDialogue.text == "...")
  283.             {
  284.                currentTimeout = setTimeout(nextPage,10000);
  285.             }
  286.             else if(curTxtDisplayCount < 20)
  287.             {
  288.                currentTimeout = setTimeout(nextPage,curTxtDisplayCount * 300);
  289.             }
  290.             else if(curTxtDisplayCount < 100)
  291.             {
  292.                currentTimeout = setTimeout(nextPage,curTxtDisplayCount * 100);
  293.             }
  294.             else
  295.             {
  296.                currentTimeout = setTimeout(nextPage,10000);
  297.             }
  298.          }
  299.          ++curTxtDelta;
  300.       }
  301.       
  302.       public function skipScene(param1:MouseEvent) : *
  303.       {
  304.          var _loc2_:CutsceneResolve = null;
  305.          _loc2_ = null;
  306.          if(cutsceneResolvePlugin != null)
  307.          {
  308.             _loc2_ = cutsceneResolves[curCutscene.DefaultResolve];
  309.             cutsceneResolvePlugin.checkResolve(_loc2_.ResolveType,_loc2_.ResolveName,this.sceneParent);
  310.          }
  311.          curTxtDisplayCount = 0;
  312.       }
  313.       
  314.       public function doneLoading() : *
  315.       {
  316.          return resources.DoneLoading;
  317.       }
  318.       
  319.       public function set CutsceneResolvePlugin(param1:ICutsceneResolvePlugin) : *
  320.       {
  321.          this.cutsceneResolvePlugin = param1;
  322.       }
  323.       
  324.       public function resolve(param1:uint, param2:String) : *
  325.       {
  326.          var _loc3_:MovieClip = null;
  327.          _loc3_ = this.sceneParent as MovieClip;
  328.          if(cutsceneResolvePlugin != null)
  329.          {
  330.             cutsceneResolvePlugin.checkResolve(param1,param2,_loc3_);
  331.             return;
  332.          }
  333.          switch(param1)
  334.          {
  335.             case 0:
  336.                unloadCutscene(false);
  337.                curCutsceneName = param2;
  338.                loadBackground();
  339.                loadCutscene();
  340.                break;
  341.             case 1:
  342.                unloadCutscene(true);
  343.                SoundManager.getInstance().stopBG();
  344.                _loc3_.gotoAndStop(param2);
  345.                _loc3_.removeEventListener(Event.ENTER_FRAME,_loc3_.onCutsceneEnterFrame);
  346.          }
  347.       }
  348.    }
  349. }
  350.